…unit tests

MultiThreadedStemmerEval hammers shared SnowballStemmer instances for
every algorithm, a SharingStemmer-wrapped PorterStemmer, and every
NormalizationProfile matching analyzer from 8 threads, comparing each
result against a single-threaded reference, mirroring
MultiThreadedToolsEval. The unit tests now also cover all 21 algorithms
under concurrency, the owner thread stemming concurrently with pool
threads, virtual threads (a fresh thread per task), and Porter sharing.

…atch baseline

Measures the thread-safe SnowballStemmer shared across threads and one
per thread against a replica of the pre-patch plain-field
implementation, at 1/8/32 threads. Results in BENCHMARKS.md: the
OwnerOrPerThreadState overhead is within error bars up to 8 threads and
only shows (~1.5x) at full 32-thread saturation.

…to-stem mappings

Natural text is Zipf-distributed, so the same words are stemmed
constantly. CachingStemmer wraps a StemmerFactory with a bounded
per-thread LRU (default 1024 entries) following the same
OwnerOrPerThreadState pattern as the *ME components: no cross-thread
sharing, thread-safe regardless of the delegate. On the JMH zipf
workload the cache is a ~34x throughput multiplier; on a cache-hostile
uniform workload over 8x the cache capacity it still breaks even.
Results and a corrected JMH invocation are documented in BENCHMARKS.md.

…ngStemmer

Builder.stem(StemmerFactory) now wraps the factory in a CachingStemmer
(default capacity), with a stem(StemmerFactory, int) overload for
explicit cache sizing, and NormalizationProfile.matchingAnalyzer()
builds through the factory again so profile analyzers get the per-thread
stem cache for free. Analyzer results are unchanged; repeated words
resolve from the cache instead of being re-stemmed.

…erflow

The cached stems are no longer routed through the JVM-wide interner: its
default implementation holds strong references forever, so open-vocabulary
input would grow without bound and defeat the documented per-thread cache
cap. The LRU alone keeps the bound honest. The LRU table sizing is computed
in double arithmetic because the int expression overflows to a negative
capacity near Integer.MAX_VALUE; a test pins construction at the extreme.
clearCache() documents that it initializes state for a thread that has not
stemmed yet.

…ures

Sixteen stemmers in the new opennlp.tools.stemmer.light package: light and
minimal tiers for German, French, Spanish, Norwegian (Bokmaal and Nynorsk
varieties), Swedish, plus light stemmers for Finnish, Hungarian, Italian,
Portuguese, Russian and the English minimal stemmer. Adapted from Apache
Lucene's analysis-common module; the UniNE algorithms carry Jacques Savoy's
BSD notice in each source file and in the distribution LICENSE. These fill
the tier between no stemming and the aggressive Snowball algorithms.

Every stemmer is stateless and thread-safe, implements Stemmer, and is its
own StemmerFactory. Input is expected lowercase, matching the algorithms'
original contract; null input fails loudly.

Parity is asserted against the original implementations: bundled fixtures
sample the algorithms' vocabulary test data (up to 2000 word/stem pairs per
stemmer, all pairs for the small Norwegian lists) regenerated by running
the Lucene classes, so any behavioral drift fails the test. The Galician
and Portuguese minimal stemmers are excluded because they build on the RSLP
rule engine, which is its own effort.

The review conventions keep JIRA keys out of source comments; the sizing note stands on its own.